package blueBridge;

import java.util.Arrays;
import java.util.Scanner;

/*

5 2
1 -2 4 3 -9
-1 4

-7

递推思路，用dp做，首先猜一波dp数组
dp[i][j]为将a中索引0~j的数分为i份的最大权值和

i\j 0   1   2   3   4   5
0   -∞  -∞  -∞  -∞  -∞  -∞
1   -∞  -1  1   -3  -6  3  
2   -∞  -∞  -7  17  29  -7

dp[i][j] = max(dp[i-1][j], dp[i-1][j-1]) + j * p[i])

以dp[2][3]为例：是[1, 2][3]还是[1][2, 3]呢？
那么比较dp[1][2] + a[2] * p[2] 和 dp[1][1] + (a[1] + a[2]) * p[2]
而dp[2][4]呢？是[1][2, 3, 4]，[1, 2][3, 4]还是[1, 2, 3][4]？
那么比较dp[1][1] + (a[1]+a[2]+a[3])*p[2]，dp[1][2] + (a[2]+a[3])*p[2]，dp[1][3] + a[3]*p[2]
即dp[i-1][j-k] + a[j-k ~ j] * p[i]
好像可以，但如果p是三个数呢，怎么分？这样行不通，怎么办？

要注意到一个细节，就是第j个a必在p[i]那组中
那么我们的递推方程为：dp[i][j] = max(dp[i][j-1] + dp[i-1][j-1]) + a[j] * p[i];
到现在我也还不明白这个递推方程怎么来的orz
然后我的代码和标准答案代码i和j反过来了，有些样例就过不了了，我也找不出哪里有问题orz


2184447506261991
2179715348485885
 
 */

public class Main12112 {
    
    long[] a;
    long[] p;
    

    private Main12112(long[] a, long[] p) {
        super();
        this.a = a;
        this.p = p;
    }
    
    private long maxPriority() {
        int n = a.length;
        int k = p.length;
        long[][] dp = new long[n+1][k+1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                dp[i][j] = Integer.MIN_VALUE;
            }
        }
        dp[0][0] = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-1]) + a[i-1] * p[j-1];
            }
        }/*
        for (int i = 0; i <= k; i++) {
            System.out.println(Arrays.toString(dp[i]));
        }
        */
        return dp[n][k];
    }


    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        long[] a = new long[n];
        long[] p = new long[k];
        for (int i = 0; i < n; i++) {
            a[i] = scan.nextInt();
        }
        for (int i = 0; i < k; i++) {
            p[i] = scan.nextInt();
        }
        Main12112 main = new Main12112(a, p);
        System.out.println(main.maxPriority());
    }

}
